/* THIS FILE IS AUTOMATICALLY GENERATED */
/* zeofuncGenerator.py 2007-11-18 14:11:39.281000 */

void calc_HF_ClipMap (ZMAP hMap, float ClipAlt, float SetAlt, int ClipMode, bool ShowProgress)
{
    static ZFUNC hFuncClipMap = NULL;
    
    if (hFuncClipMap == NULL)
        hFuncClipMap = theAPI.zeofunc_GetFunc("calc.HF.ClipMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarClipAlt = theAPI.list_CreateItem(hArgs, VarID_float, "ClipAlt");
    theAPI.var_SetValue(hVarClipAlt, &ClipAlt);

    ZVAR hVarSetAlt = theAPI.list_CreateItem(hArgs, VarID_float, "SetAlt");
    theAPI.var_SetValue(hVarSetAlt, &SetAlt);

    ZVAR hVarClipMode = theAPI.list_CreateItem(hArgs, VarID_int, "ClipMode");
    theAPI.var_SetValue(hVarClipMode, &ClipMode);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncClipMap, hArgs, &hRetVar);
    return;
}

void calc_HF_ClampMap (ZMAP hMap, float MinAlt, float MaxAlt, bool ShowProgress)
{
    static ZFUNC hFuncClampMap = NULL;
    
    if (hFuncClampMap == NULL)
        hFuncClampMap = theAPI.zeofunc_GetFunc("calc.HF.ClampMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarMinAlt = theAPI.list_CreateItem(hArgs, VarID_float, "MinAlt");
    theAPI.var_SetValue(hVarMinAlt, &MinAlt);

    ZVAR hVarMaxAlt = theAPI.list_CreateItem(hArgs, VarID_float, "MaxAlt");
    theAPI.var_SetValue(hVarMaxAlt, &MaxAlt);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncClampMap, hArgs, &hRetVar);
    return;
}

void calc_HF_ScaleMap (ZMAP hMap, float val, bool ShowProgress)
{
    static ZFUNC hFuncScaleMap = NULL;
    
    if (hFuncScaleMap == NULL)
        hFuncScaleMap = theAPI.zeofunc_GetFunc("calc.HF.ScaleMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarval = theAPI.list_CreateItem(hArgs, VarID_float, "val");
    theAPI.var_SetValue(hVarval, &val);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncScaleMap, hArgs, &hRetVar);
    return;
}

void calc_HF_ShiftMap (ZMAP hMap, float val, bool ShowProgress)
{
    static ZFUNC hFuncShiftMap = NULL;
    
    if (hFuncShiftMap == NULL)
        hFuncShiftMap = theAPI.zeofunc_GetFunc("calc.HF.ShiftMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarval = theAPI.list_CreateItem(hArgs, VarID_float, "val");
    theAPI.var_SetValue(hVarval, &val);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncShiftMap, hArgs, &hRetVar);
    return;
}

void calc_HF_GradFilter (ZMAP hMap, int nLevels, float Threshold, bool ShowProgress, LPVOID pMaskMap)
{
    static ZFUNC hFuncGradFilter = NULL;
    
    if (hFuncGradFilter == NULL)
        hFuncGradFilter = theAPI.zeofunc_GetFunc("calc.HF.GradFilter");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarnLevels = theAPI.list_CreateItem(hArgs, VarID_int, "nLevels");
    theAPI.var_SetValue(hVarnLevels, &nLevels);

    ZVAR hVarThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "Threshold");
    theAPI.var_SetValue(hVarThreshold, &Threshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hVarpMaskMap = theAPI.list_CreateItem(hArgs, VarID_LPVOID, "pMaskMap");
    theAPI.var_SetVarRef(hVarpMaskMap, pMaskMap);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGradFilter, hArgs, &hRetVar);
    return;
}

void calc_HF_CurvFilter (ZMAP hMap, int nLevels, float Threshold, bool ShowProgress, LPVOID pMaskMap)
{
    static ZFUNC hFuncCurvFilter = NULL;
    
    if (hFuncCurvFilter == NULL)
        hFuncCurvFilter = theAPI.zeofunc_GetFunc("calc.HF.CurvFilter");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarnLevels = theAPI.list_CreateItem(hArgs, VarID_int, "nLevels");
    theAPI.var_SetValue(hVarnLevels, &nLevels);

    ZVAR hVarThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "Threshold");
    theAPI.var_SetValue(hVarThreshold, &Threshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hVarpMaskMap = theAPI.list_CreateItem(hArgs, VarID_LPVOID, "pMaskMap");
    theAPI.var_SetVarRef(hVarpMaskMap, pMaskMap);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncCurvFilter, hArgs, &hRetVar);
    return;
}

void calc_HF_ErodeChannel (ZMAP hMap, int MaxCycles, int MinLength, int MaxLength, float DeltaHF, float MemDecay, bool BlurDir, bool ShowProgress)
{
    static ZFUNC hFuncErodeChannel = NULL;
    
    if (hFuncErodeChannel == NULL)
        hFuncErodeChannel = theAPI.zeofunc_GetFunc("calc.HF.ErodeChannel");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarMaxCycles = theAPI.list_CreateItem(hArgs, VarID_int, "MaxCycles");
    theAPI.var_SetValue(hVarMaxCycles, &MaxCycles);

    ZVAR hVarMinLength = theAPI.list_CreateItem(hArgs, VarID_int, "MinLength");
    theAPI.var_SetValue(hVarMinLength, &MinLength);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarDeltaHF = theAPI.list_CreateItem(hArgs, VarID_float, "DeltaHF");
    theAPI.var_SetValue(hVarDeltaHF, &DeltaHF);

    ZVAR hVarMemDecay = theAPI.list_CreateItem(hArgs, VarID_float, "MemDecay");
    theAPI.var_SetValue(hVarMemDecay, &MemDecay);

    ZVAR hVarBlurDir = theAPI.list_CreateItem(hArgs, VarID_bool, "BlurDir");
    theAPI.var_SetValue(hVarBlurDir, &BlurDir);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncErodeChannel, hArgs, &hRetVar);
    return;
}

void calc_HF_ErodeChannelEx (ZMAP hMap, ZMAP hMaskMap, int MinLength, int MaxLength, float DeltaHF, float MemDecay, bool BlurDir, bool ShowProgress)
{
    static ZFUNC hFuncErodeChannelEx = NULL;
    
    if (hFuncErodeChannelEx == NULL)
        hFuncErodeChannelEx = theAPI.zeofunc_GetFunc("calc.HF.ErodeChannelEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhMaskMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMaskMap");
    theAPI.var_SetVarRef(hVarhMaskMap, hMaskMap);

    ZVAR hVarMinLength = theAPI.list_CreateItem(hArgs, VarID_int, "MinLength");
    theAPI.var_SetValue(hVarMinLength, &MinLength);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarDeltaHF = theAPI.list_CreateItem(hArgs, VarID_float, "DeltaHF");
    theAPI.var_SetValue(hVarDeltaHF, &DeltaHF);

    ZVAR hVarMemDecay = theAPI.list_CreateItem(hArgs, VarID_float, "MemDecay");
    theAPI.var_SetValue(hVarMemDecay, &MemDecay);

    ZVAR hVarBlurDir = theAPI.list_CreateItem(hArgs, VarID_bool, "BlurDir");
    theAPI.var_SetValue(hVarBlurDir, &BlurDir);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncErodeChannelEx, hArgs, &hRetVar);
    return;
}

void calc_HF_ErodeThermal (ZMAP hMap, int MaxCycles, int MaxLength, float LossFraction, float GradThreshold, bool ShowProgress)
{
    static ZFUNC hFuncErodeThermal = NULL;
    
    if (hFuncErodeThermal == NULL)
        hFuncErodeThermal = theAPI.zeofunc_GetFunc("calc.HF.ErodeThermal");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarMaxCycles = theAPI.list_CreateItem(hArgs, VarID_int, "MaxCycles");
    theAPI.var_SetValue(hVarMaxCycles, &MaxCycles);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarLossFraction = theAPI.list_CreateItem(hArgs, VarID_float, "LossFraction");
    theAPI.var_SetValue(hVarLossFraction, &LossFraction);

    ZVAR hVarGradThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "GradThreshold");
    theAPI.var_SetValue(hVarGradThreshold, &GradThreshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncErodeThermal, hArgs, &hRetVar);
    return;
}

void calc_HF_ErodeThermalEx (ZMAP hMap, ZMAP hMaskMap, int MaxLength, float LossFraction, float GradThreshold, bool ShowProgress)
{
    static ZFUNC hFuncErodeThermalEx = NULL;
    
    if (hFuncErodeThermalEx == NULL)
        hFuncErodeThermalEx = theAPI.zeofunc_GetFunc("calc.HF.ErodeThermalEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhMaskMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMaskMap");
    theAPI.var_SetVarRef(hVarhMaskMap, hMaskMap);

    ZVAR hVarMaxLength = theAPI.list_CreateItem(hArgs, VarID_int, "MaxLength");
    theAPI.var_SetValue(hVarMaxLength, &MaxLength);

    ZVAR hVarLossFraction = theAPI.list_CreateItem(hArgs, VarID_float, "LossFraction");
    theAPI.var_SetValue(hVarLossFraction, &LossFraction);

    ZVAR hVarGradThreshold = theAPI.list_CreateItem(hArgs, VarID_float, "GradThreshold");
    theAPI.var_SetValue(hVarGradThreshold, &GradThreshold);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncErodeThermalEx, hArgs, &hRetVar);
    return;
}

void calc_HF_Inflate (ZMAP hHF, ZMAP hDM, int levels)
{
    static ZFUNC hFuncInflate = NULL;
    
    if (hFuncInflate == NULL)
        hFuncInflate = theAPI.zeofunc_GetFunc("calc.HF.Inflate");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhHF = theAPI.list_CreateItem(hArgs, VarID_map, "hHF");
    theAPI.var_SetVarRef(hVarhHF, hHF);

    ZVAR hVarhDM = theAPI.list_CreateItem(hArgs, VarID_map, "hDM");
    theAPI.var_SetVarRef(hVarhDM, hDM);

    ZVAR hVarlevels = theAPI.list_CreateItem(hArgs, VarID_int, "levels");
    theAPI.var_SetValue(hVarlevels, &levels);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncInflate, hArgs, &hRetVar);
    return;
}

void calc_HF_InflateMosaic (ZMAP hMapSrc, ZMAP hMapDest, const char * FileName, const char * MapName, int TileSize, ZFORMAT hFormat, ZMAP hDM, int levels)
{
    static ZFUNC hFuncInflateMosaic = NULL;
    
    if (hFuncInflateMosaic == NULL)
        hFuncInflateMosaic = theAPI.zeofunc_GetFunc("calc.HF.InflateMosaic");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMapSrc = theAPI.list_CreateItem(hArgs, VarID_map, "hMapSrc");
    theAPI.var_SetVarRef(hVarhMapSrc, hMapSrc);

    ZVAR hVarhMapDest = theAPI.list_CreateItem(hArgs, VarID_map, "hMapDest");
    theAPI.var_SetVarRef(hVarhMapDest, hMapDest);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hVarTileSize = theAPI.list_CreateItem(hArgs, VarID_int, "TileSize");
    theAPI.var_SetValue(hVarTileSize, &TileSize);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hVarhDM = theAPI.list_CreateItem(hArgs, VarID_map, "hDM");
    theAPI.var_SetVarRef(hVarhDM, hDM);

    ZVAR hVarlevels = theAPI.list_CreateItem(hArgs, VarID_int, "levels");
    theAPI.var_SetValue(hVarlevels, &levels);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncInflateMosaic, hArgs, &hRetVar);
    return;
}

bool calc_HF_GenPeakOverlay (ZMAP hMap, int Radius, float Height, int ShapeMode)
{
    static ZFUNC hFuncGenPeakOverlay = NULL;
    
    if (hFuncGenPeakOverlay == NULL)
        hFuncGenPeakOverlay = theAPI.zeofunc_GetFunc("calc.HF.GenPeakOverlay");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarRadius = theAPI.list_CreateItem(hArgs, VarID_int, "Radius");
    theAPI.var_SetValue(hVarRadius, &Radius);

    ZVAR hVarHeight = theAPI.list_CreateItem(hArgs, VarID_float, "Height");
    theAPI.var_SetValue(hVarHeight, &Height);

    ZVAR hVarShapeMode = theAPI.list_CreateItem(hArgs, VarID_int, "ShapeMode");
    theAPI.var_SetValue(hVarShapeMode, &ShapeMode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenPeakOverlay, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

void calc_HF_CombineMaps (ZMAP hMap1, ZMAP hMap2, int MixMode, int offset_xmid, int offset_ymid)
{
    static ZFUNC hFuncCombineMaps = NULL;
    
    if (hFuncCombineMaps == NULL)
        hFuncCombineMaps = theAPI.zeofunc_GetFunc("calc.HF.CombineMaps");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap1 = theAPI.list_CreateItem(hArgs, VarID_map, "hMap1");
    theAPI.var_SetVarRef(hVarhMap1, hMap1);

    ZVAR hVarhMap2 = theAPI.list_CreateItem(hArgs, VarID_map, "hMap2");
    theAPI.var_SetVarRef(hVarhMap2, hMap2);

    ZVAR hVarMixMode = theAPI.list_CreateItem(hArgs, VarID_int, "MixMode");
    theAPI.var_SetValue(hVarMixMode, &MixMode);

    ZVAR hVaroffset_xmid = theAPI.list_CreateItem(hArgs, VarID_int, "offset_xmid");
    theAPI.var_SetValue(hVaroffset_xmid, &offset_xmid);

    ZVAR hVaroffset_ymid = theAPI.list_CreateItem(hArgs, VarID_int, "offset_ymid");
    theAPI.var_SetValue(hVaroffset_ymid, &offset_ymid);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncCombineMaps, hArgs, &hRetVar);
    return;
}

void calc_HF_ApplyOverlay (ZMAP hMap, ZMAP hOverlay, int xpos, int ypos, float zStretch, bool FreeMap)
{
    static ZFUNC hFuncApplyOverlay = NULL;
    
    if (hFuncApplyOverlay == NULL)
        hFuncApplyOverlay = theAPI.zeofunc_GetFunc("calc.HF.ApplyOverlay");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhOverlay = theAPI.list_CreateItem(hArgs, VarID_map, "hOverlay");
    theAPI.var_SetVarRef(hVarhOverlay, hOverlay);

    ZVAR hVarxpos = theAPI.list_CreateItem(hArgs, VarID_int, "xpos");
    theAPI.var_SetValue(hVarxpos, &xpos);

    ZVAR hVarypos = theAPI.list_CreateItem(hArgs, VarID_int, "ypos");
    theAPI.var_SetValue(hVarypos, &ypos);

    ZVAR hVarzStretch = theAPI.list_CreateItem(hArgs, VarID_float, "zStretch");
    theAPI.var_SetValue(hVarzStretch, &zStretch);

    ZVAR hVarFreeMap = theAPI.list_CreateItem(hArgs, VarID_bool, "FreeMap");
    theAPI.var_SetValue(hVarFreeMap, &FreeMap);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncApplyOverlay, hArgs, &hRetVar);
    return;
}

void calc_HF_ApplyOverlayMax (ZMAP hMap, ZMAP hOverlay, int xpos, int ypos)
{
    static ZFUNC hFuncApplyOverlayMax = NULL;
    
    if (hFuncApplyOverlayMax == NULL)
        hFuncApplyOverlayMax = theAPI.zeofunc_GetFunc("calc.HF.ApplyOverlayMax");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhOverlay = theAPI.list_CreateItem(hArgs, VarID_map, "hOverlay");
    theAPI.var_SetVarRef(hVarhOverlay, hOverlay);

    ZVAR hVarxpos = theAPI.list_CreateItem(hArgs, VarID_int, "xpos");
    theAPI.var_SetValue(hVarxpos, &xpos);

    ZVAR hVarypos = theAPI.list_CreateItem(hArgs, VarID_int, "ypos");
    theAPI.var_SetValue(hVarypos, &ypos);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncApplyOverlayMax, hArgs, &hRetVar);
    return;
}

void calc_HF_ApplyOverlayMin (ZMAP hMap, ZMAP hOverlay, int xpos, int ypos)
{
    static ZFUNC hFuncApplyOverlayMin = NULL;
    
    if (hFuncApplyOverlayMin == NULL)
        hFuncApplyOverlayMin = theAPI.zeofunc_GetFunc("calc.HF.ApplyOverlayMin");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhOverlay = theAPI.list_CreateItem(hArgs, VarID_map, "hOverlay");
    theAPI.var_SetVarRef(hVarhOverlay, hOverlay);

    ZVAR hVarxpos = theAPI.list_CreateItem(hArgs, VarID_int, "xpos");
    theAPI.var_SetValue(hVarxpos, &xpos);

    ZVAR hVarypos = theAPI.list_CreateItem(hArgs, VarID_int, "ypos");
    theAPI.var_SetValue(hVarypos, &ypos);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncApplyOverlayMin, hArgs, &hRetVar);
    return;
}

ZLIST calc_AM_GetFilterList ()
{
    static ZFUNC hFuncGetFilterList = NULL;
    
    if (hFuncGetFilterList == NULL)
        hFuncGetFilterList = theAPI.zeofunc_GetFunc("calc.AM.GetFilterList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetFilterList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
short calc_AM_FilterPixel (short InputCode, ZVAR Buf, ZLIST Filter)
{
    static ZFUNC hFuncFilterPixel = NULL;
    
    if (hFuncFilterPixel == NULL)
        hFuncFilterPixel = theAPI.zeofunc_GetFunc("calc.AM.FilterPixel");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hVarBuf = theAPI.list_CreateItem(hArgs, VarID_buffer, "Buf");
    theAPI.var_SetVarRef(hVarBuf, Buf);

    ZVAR hVarFilter = theAPI.list_CreateItem(hArgs, VarID_varlist, "Filter");
    theAPI.var_SetVarRef(hVarFilter, Filter);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncFilterPixel, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        short retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZVAR calc_AM_GetClimateByCode (short InputCode)
{
    static ZFUNC hFuncGetClimateByCode = NULL;
    
    if (hFuncGetClimateByCode == NULL)
        hFuncGetClimateByCode = theAPI.zeofunc_GetFunc("calc.AM.GetClimateByCode");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetClimateByCode, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZVAR retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZVAR calc_AM_GetLandTypeByCode (short InputCode)
{
    static ZFUNC hFuncGetLandTypeByCode = NULL;
    
    if (hFuncGetLandTypeByCode == NULL)
        hFuncGetLandTypeByCode = theAPI.zeofunc_GetFunc("calc.AM.GetLandTypeByCode");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetLandTypeByCode, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZVAR retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZVAR calc_AM_GetPixelColour (short InputCode)
{
    static ZFUNC hFuncGetPixelColour = NULL;
    
    if (hFuncGetPixelColour == NULL)
        hFuncGetPixelColour = theAPI.zeofunc_GetFunc("calc.AM.GetPixelColour");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetPixelColour, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZVAR retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

short calc_AM_GetIDfromColour (ZVAR InputColour)
{
    static ZFUNC hFuncGetIDfromColour = NULL;
    
    if (hFuncGetIDfromColour == NULL)
        hFuncGetIDfromColour = theAPI.zeofunc_GetFunc("calc.AM.GetIDfromColour");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputColour = theAPI.list_CreateItem(hArgs, VarID_colour, "InputColour");
    theAPI.var_SetVarRef(hVarInputColour, InputColour);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetIDfromColour, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        short retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

void calc_AM_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.AM.GenMap");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenMap, NULL, &hRetVar);
    return;
}
void calc_TN_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.TN.GenMap");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenMap, NULL, &hRetVar);
    return;
}
bool calc_TN_GenArea (int TileStateFlag, ZLIST maps, ZLIST area, ZLIST params, ZLIST prog)
{
    static ZFUNC hFuncGenArea = NULL;
    
    if (hFuncGenArea == NULL)
        hFuncGenArea = theAPI.zeofunc_GetFunc("calc.TN.GenArea");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarTileStateFlag = theAPI.list_CreateItem(hArgs, VarID_int, "TileStateFlag");
    theAPI.var_SetValue(hVarTileStateFlag, &TileStateFlag);

    ZVAR hVarmaps = theAPI.list_CreateItem(hArgs, VarID_varlist, "maps");
    theAPI.var_SetVarRef(hVarmaps, maps);

    ZVAR hVararea = theAPI.list_CreateItem(hArgs, VarID_varlist, "area");
    theAPI.var_SetVarRef(hVararea, area);

    ZVAR hVarparams = theAPI.list_CreateItem(hArgs, VarID_varlist, "params");
    theAPI.var_SetVarRef(hVarparams, params);

    ZVAR hVarprog = theAPI.list_CreateItem(hArgs, VarID_varlist, "prog");
    theAPI.var_SetVarRef(hVarprog, prog);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenArea, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

void calc_LM_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.LM.GenMap");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenMap, NULL, &hRetVar);
    return;
}
void calc_TX_GenMap ()
{
    static ZFUNC hFuncGenMap = NULL;
    
    if (hFuncGenMap == NULL)
        hFuncGenMap = theAPI.zeofunc_GetFunc("calc.TX.GenMap");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGenMap, NULL, &hRetVar);
    return;
}
bool calc_TX_GenMapPro_CalcArea (int TileStateFlag, ZLIST maps, ZLIST area, ZLIST params, ZLIST prog)
{
    static ZFUNC hFuncCalcArea = NULL;
    
    if (hFuncCalcArea == NULL)
        hFuncCalcArea = theAPI.zeofunc_GetFunc("calc.TX.GenMapPro.CalcArea");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarTileStateFlag = theAPI.list_CreateItem(hArgs, VarID_int, "TileStateFlag");
    theAPI.var_SetValue(hVarTileStateFlag, &TileStateFlag);

    ZVAR hVarmaps = theAPI.list_CreateItem(hArgs, VarID_varlist, "maps");
    theAPI.var_SetVarRef(hVarmaps, maps);

    ZVAR hVararea = theAPI.list_CreateItem(hArgs, VarID_varlist, "area");
    theAPI.var_SetVarRef(hVararea, area);

    ZVAR hVarparams = theAPI.list_CreateItem(hArgs, VarID_varlist, "params");
    theAPI.var_SetVarRef(hVarparams, params);

    ZVAR hVarprog = theAPI.list_CreateItem(hArgs, VarID_varlist, "prog");
    theAPI.var_SetVarRef(hVarprog, prog);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncCalcArea, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZLIST calc_alpha_ExportExpress (const char * FileName, ZMAP hMap, ZLIST hFilter, ZFORMAT hFormat, int LayersPerImage, bool MosaicFlag, int TileSize, bool ShowReport)
{
    static ZFUNC hFuncExportExpress = NULL;
    
    if (hFuncExportExpress == NULL)
        hFuncExportExpress = theAPI.zeofunc_GetFunc("calc.alpha.ExportExpress");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarhFilter = theAPI.list_CreateItem(hArgs, VarID_varlist, "hFilter");
    theAPI.var_SetVarRef(hVarhFilter, hFilter);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hVarLayersPerImage = theAPI.list_CreateItem(hArgs, VarID_int, "LayersPerImage");
    theAPI.var_SetValue(hVarLayersPerImage, &LayersPerImage);

    ZVAR hVarMosaicFlag = theAPI.list_CreateItem(hArgs, VarID_bool, "MosaicFlag");
    theAPI.var_SetValue(hVarMosaicFlag, &MosaicFlag);

    ZVAR hVarTileSize = theAPI.list_CreateItem(hArgs, VarID_int, "TileSize");
    theAPI.var_SetValue(hVarTileSize, &TileSize);

    ZVAR hVarShowReport = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowReport");
    theAPI.var_SetValue(hVarShowReport, &ShowReport);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExportExpress, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * classes_landtype_GetBaseTextureNameByID (short InputCode)
{
    static ZFUNC hFuncGetBaseTextureNameByID = NULL;
    
    if (hFuncGetBaseTextureNameByID == NULL)
        hFuncGetBaseTextureNameByID = theAPI.zeofunc_GetFunc("classes.landtype.GetBaseTextureNameByID");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetBaseTextureNameByID, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * classes_landtype_GetTypeNameByID (short InputCode)
{
    static ZFUNC hFuncGetTypeNameByID = NULL;
    
    if (hFuncGetTypeNameByID == NULL)
        hFuncGetTypeNameByID = theAPI.zeofunc_GetFunc("classes.landtype.GetTypeNameByID");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarInputCode = theAPI.list_CreateItem(hArgs, VarID_short, "InputCode");
    theAPI.var_SetValue(hVarInputCode, &InputCode);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetTypeNameByID, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * classes_landtype_GetName (ZVAR hLandType)
{
    static ZFUNC hFuncGetName = NULL;
    
    if (hFuncGetName == NULL)
        hFuncGetName = theAPI.zeofunc_GetFunc("classes.landtype.GetName");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhLandType = theAPI.list_CreateItem(hArgs, VarID_LandType, "hLandType");
    theAPI.var_SetVarRef(hVarhLandType, hLandType);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetName, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZFORMAT classes_format_GetActiveFormat (const char * MapName, int MapTypeID)
{
    static ZFUNC hFuncGetActiveFormat = NULL;
    
    if (hFuncGetActiveFormat == NULL)
        hFuncGetActiveFormat = theAPI.zeofunc_GetFunc("classes.format.GetActiveFormat");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hVarMapTypeID = theAPI.list_CreateItem(hArgs, VarID_int, "MapTypeID");
    theAPI.var_SetValue(hVarMapTypeID, &MapTypeID);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetActiveFormat, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZFORMAT retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZLIST classes_climate_GetTypeList (ZVAR hClimate)
{
    static ZFUNC hFuncGetTypeList = NULL;
    
    if (hFuncGetTypeList == NULL)
        hFuncGetTypeList = theAPI.zeofunc_GetFunc("classes.climate.GetTypeList");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhClimate = theAPI.list_CreateItem(hArgs, VarID_Climate, "hClimate");
    theAPI.var_SetVarRef(hVarhClimate, hClimate);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetTypeList, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * classes_climate_GetName (ZVAR hClimate)
{
    static ZFUNC hFuncGetName = NULL;
    
    if (hFuncGetName == NULL)
        hFuncGetName = theAPI.zeofunc_GetFunc("classes.climate.GetName");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhClimate = theAPI.list_CreateItem(hArgs, VarID_Climate, "hClimate");
    theAPI.var_SetVarRef(hVarhClimate, hClimate);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetName, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool threadman_RunTiles (ZFUNC hTileFn, ZLIST TileList)
{
    static ZFUNC hFuncRunTiles = NULL;
    
    if (hFuncRunTiles == NULL)
        hFuncRunTiles = theAPI.zeofunc_GetFunc("threadman.RunTiles");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhTileFn = theAPI.list_CreateItem(hArgs, VarID_ZeoFunc, "hTileFn");
    theAPI.var_SetVarRef(hVarhTileFn, hTileFn);

    ZVAR hVarTileList = theAPI.list_CreateItem(hArgs, VarID_varlist, "TileList");
    theAPI.var_SetVarRef(hVarTileList, TileList);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncRunTiles, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZLIST zeofunc_GetFuncList ()
{
    static ZFUNC hFuncGetFuncList = NULL;
    
    if (hFuncGetFuncList == NULL)
        hFuncGetFuncList = theAPI.zeofunc_GetFunc("zeofunc.GetFuncList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetFuncList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
const char * application_GetTempDir ()
{
    static ZFUNC hFuncGetTempDir = NULL;
    
    if (hFuncGetTempDir == NULL)
        hFuncGetTempDir = theAPI.zeofunc_GetFunc("application.GetTempDir");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetTempDir, NULL, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
int application_GetUID ()
{
    static ZFUNC hFuncGetUID = NULL;
    
    if (hFuncGetUID == NULL)
        hFuncGetUID = theAPI.zeofunc_GetFunc("application.GetUID");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetUID, NULL, &hRetVar);
    
    if (bExecResult)
    {
        int retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
ZLIST settings_GetPresetsList ()
{
    static ZFUNC hFuncGetPresetsList = NULL;
    
    if (hFuncGetPresetsList == NULL)
        hFuncGetPresetsList = theAPI.zeofunc_GetFunc("settings.GetPresetsList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetPresetsList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool project_IsInit ()
{
    static ZFUNC hFuncIsInit = NULL;
    
    if (hFuncIsInit == NULL)
        hFuncIsInit = theAPI.zeofunc_GetFunc("project.IsInit");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncIsInit, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool project_InitProject ()
{
    static ZFUNC hFuncInitProject = NULL;
    
    if (hFuncInitProject == NULL)
        hFuncInitProject = theAPI.zeofunc_GetFunc("project.InitProject");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncInitProject, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool project_FreeProject ()
{
    static ZFUNC hFuncFreeProject = NULL;
    
    if (hFuncFreeProject == NULL)
        hFuncFreeProject = theAPI.zeofunc_GetFunc("project.FreeProject");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncFreeProject, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool project_LoadProject (const char * FileName)
{
    static ZFUNC hFuncLoadProject = NULL;
    
    if (hFuncLoadProject == NULL)
        hFuncLoadProject = theAPI.zeofunc_GetFunc("project.LoadProject");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadProject, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool project_SaveProject ()
{
    static ZFUNC hFuncSaveProject = NULL;
    
    if (hFuncSaveProject == NULL)
        hFuncSaveProject = theAPI.zeofunc_GetFunc("project.SaveProject");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncSaveProject, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool project_SaveProjectAs (const char * FileName)
{
    static ZFUNC hFuncSaveProjectAs = NULL;
    
    if (hFuncSaveProjectAs == NULL)
        hFuncSaveProjectAs = theAPI.zeofunc_GetFunc("project.SaveProjectAs");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncSaveProjectAs, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * project_SaveProjectAsUI ()
{
    static ZFUNC hFuncSaveProjectAsUI = NULL;
    
    if (hFuncSaveProjectAsUI == NULL)
        hFuncSaveProjectAsUI = theAPI.zeofunc_GetFunc("project.SaveProjectAsUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncSaveProjectAsUI, NULL, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
const char * project_GetProjectPath ()
{
    static ZFUNC hFuncGetProjectPath = NULL;
    
    if (hFuncGetProjectPath == NULL)
        hFuncGetProjectPath = theAPI.zeofunc_GetFunc("project.GetProjectPath");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetProjectPath, NULL, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
LPVOID project_CreateMap (const char * MapName)
{
    static ZFUNC hFuncCreateMap = NULL;
    
    if (hFuncCreateMap == NULL)
        hFuncCreateMap = theAPI.zeofunc_GetFunc("project.CreateMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncCreateMap, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        LPVOID retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

LPVOID project_GetMap (const char * MapName)
{
    static ZFUNC hFuncGetMap = NULL;
    
    if (hFuncGetMap == NULL)
        hFuncGetMap = theAPI.zeofunc_GetFunc("project.GetMap");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarMapName = theAPI.list_CreateItem(hArgs, VarID_string, "MapName");
    theAPI.str_SetText(hVarMapName, MapName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetMap, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        LPVOID retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZLIST project_GetSettingsList ()
{
    static ZFUNC hFuncGetSettingsList = NULL;
    
    if (hFuncGetSettingsList == NULL)
        hFuncGetSettingsList = theAPI.zeofunc_GetFunc("project.GetSettingsList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetSettingsList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
ZLIST project_GetHeightfieldRange ()
{
    static ZFUNC hFuncGetHeightfieldRange = NULL;
    
    if (hFuncGetHeightfieldRange == NULL)
        hFuncGetHeightfieldRange = theAPI.zeofunc_GetFunc("project.GetHeightfieldRange");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetHeightfieldRange, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
void file_export_atlasEx (ZLIST MapList, const char * FileName, ZLIST Options)
{
    static ZFUNC hFuncatlasEx = NULL;
    
    if (hFuncatlasEx == NULL)
        hFuncatlasEx = theAPI.zeofunc_GetFunc("file.export.atlasEx");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarMapList = theAPI.list_CreateItem(hArgs, VarID_varlist, "MapList");
    theAPI.var_SetVarRef(hVarMapList, MapList);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarOptions = theAPI.list_CreateItem(hArgs, VarID_varlist, "Options");
    theAPI.var_SetVarRef(hVarOptions, Options);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncatlasEx, hArgs, &hRetVar);
    return;
}

bool file_export_area (ZMAP hMap, const char * FileName, ZFORMAT hFormat, int x1, int x2, int y1, int y2)
{
    static ZFUNC hFuncarea = NULL;
    
    if (hFuncarea == NULL)
        hFuncarea = theAPI.zeofunc_GetFunc("file.export.area");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hVarx1 = theAPI.list_CreateItem(hArgs, VarID_int, "x1");
    theAPI.var_SetValue(hVarx1, &x1);

    ZVAR hVarx2 = theAPI.list_CreateItem(hArgs, VarID_int, "x2");
    theAPI.var_SetValue(hVarx2, &x2);

    ZVAR hVary1 = theAPI.list_CreateItem(hArgs, VarID_int, "y1");
    theAPI.var_SetValue(hVary1, &y1);

    ZVAR hVary2 = theAPI.list_CreateItem(hArgs, VarID_int, "y2");
    theAPI.var_SetValue(hVary2, &y2);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncarea, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * file_SaveDlg (const char * DefaultExtension, const char * StartFilename, const char * FileFilter)
{
    static ZFUNC hFuncSaveDlg = NULL;
    
    if (hFuncSaveDlg == NULL)
        hFuncSaveDlg = theAPI.zeofunc_GetFunc("file.SaveDlg");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarDefaultExtension = theAPI.list_CreateItem(hArgs, VarID_string, "DefaultExtension");
    theAPI.str_SetText(hVarDefaultExtension, DefaultExtension);

    ZVAR hVarStartFilename = theAPI.list_CreateItem(hArgs, VarID_string, "StartFilename");
    theAPI.str_SetText(hVarStartFilename, StartFilename);

    ZVAR hVarFileFilter = theAPI.list_CreateItem(hArgs, VarID_string, "FileFilter");
    theAPI.str_SetText(hVarFileFilter, FileFilter);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncSaveDlg, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

const char * file_OpenDlg (const char * DefaultExtension, const char * StartFilename, const char * FileFilter)
{
    static ZFUNC hFuncOpenDlg = NULL;
    
    if (hFuncOpenDlg == NULL)
        hFuncOpenDlg = theAPI.zeofunc_GetFunc("file.OpenDlg");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarDefaultExtension = theAPI.list_CreateItem(hArgs, VarID_string, "DefaultExtension");
    theAPI.str_SetText(hVarDefaultExtension, DefaultExtension);

    ZVAR hVarStartFilename = theAPI.list_CreateItem(hArgs, VarID_string, "StartFilename");
    theAPI.str_SetText(hVarStartFilename, StartFilename);

    ZVAR hVarFileFilter = theAPI.list_CreateItem(hArgs, VarID_string, "FileFilter");
    theAPI.str_SetText(hVarFileFilter, FileFilter);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncOpenDlg, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        const char * retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

ZLIST climate_GetClimateList ()
{
    static ZFUNC hFuncGetClimateList = NULL;
    
    if (hFuncGetClimateList == NULL)
        hFuncGetClimateList = theAPI.zeofunc_GetFunc("climate.GetClimateList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncGetClimateList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        ZLIST retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool ExtAPI_map_SaveFile (ZMAP hMap, const char * Filename, ZFORMAT hFormat, bool SetFlags, bool ShowProgress)
{
    static ZFUNC hFuncSaveFile = NULL;
    
    if (hFuncSaveFile == NULL)
        hFuncSaveFile = theAPI.zeofunc_GetFunc("ExtAPI.map.SaveFile");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarFilename = theAPI.list_CreateItem(hArgs, VarID_string, "Filename");
    theAPI.str_SetText(hVarFilename, Filename);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hVarSetFlags = theAPI.list_CreateItem(hArgs, VarID_bool, "SetFlags");
    theAPI.var_SetValue(hVarSetFlags, &SetFlags);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncSaveFile, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool ExtAPI_map_LoadFile (ZMAP hMap, const char * Filename, int MapTypeID, ZFORMAT hFormat, bool SetFlags, bool ShowProgress)
{
    static ZFUNC hFuncLoadFile = NULL;
    
    if (hFuncLoadFile == NULL)
        hFuncLoadFile = theAPI.zeofunc_GetFunc("ExtAPI.map.LoadFile");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarFilename = theAPI.list_CreateItem(hArgs, VarID_string, "Filename");
    theAPI.str_SetText(hVarFilename, Filename);

    ZVAR hVarMapTypeID = theAPI.list_CreateItem(hArgs, VarID_int, "MapTypeID");
    theAPI.var_SetValue(hVarMapTypeID, &MapTypeID);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hVarSetFlags = theAPI.list_CreateItem(hArgs, VarID_bool, "SetFlags");
    theAPI.var_SetValue(hVarSetFlags, &SetFlags);

    ZVAR hVarShowProgress = theAPI.list_CreateItem(hArgs, VarID_bool, "ShowProgress");
    theAPI.var_SetValue(hVarShowProgress, &ShowProgress);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadFile, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool ExtAPI_var_EditUI (hVar hVar, const char * Prompt)
{
    static ZFUNC hFuncEditUI = NULL;
    
    if (hFuncEditUI == NULL)
        hFuncEditUI = theAPI.zeofunc_GetFunc("ExtAPI.var.EditUI");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhVar = theAPI.list_CreateItem(hArgs, VarID_hVar, "hVar");
    theAPI.var_SetVarRef(hVarhVar, hVar);

    ZVAR hVarPrompt = theAPI.list_CreateItem(hArgs, VarID_string, "Prompt");
    theAPI.str_SetText(hVarPrompt, Prompt);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncEditUI, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

void Sapphire_ExtRenderHF ()
{
    static ZFUNC hFuncExtRenderHF = NULL;
    
    if (hFuncExtRenderHF == NULL)
        hFuncExtRenderHF = theAPI.zeofunc_GetFunc("Sapphire.ExtRenderHF");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtRenderHF, NULL, &hRetVar);
    return;
}
void Sapphire_ExtEditHF ()
{
    static ZFUNC hFuncExtEditHF = NULL;
    
    if (hFuncExtEditHF == NULL)
        hFuncExtEditHF = theAPI.zeofunc_GetFunc("Sapphire.ExtEditHF");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtEditHF, NULL, &hRetVar);
    return;
}
void Sapphire_ExtEditSettings ()
{
    static ZFUNC hFuncExtEditSettings = NULL;
    
    if (hFuncExtEditSettings == NULL)
        hFuncExtEditSettings = theAPI.zeofunc_GetFunc("Sapphire.ExtEditSettings");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtEditSettings, NULL, &hRetVar);
    return;
}
void Sapphire_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("Sapphire.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void CopyPaste_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("CopyPaste.ExtAbout");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAbout, NULL, &hRetVar);
    return;
}
void CopyPaste_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("CopyPaste.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void CopyPaste_ExtToggleWnd ()
{
    static ZFUNC hFuncExtToggleWnd = NULL;
    
    if (hFuncExtToggleWnd == NULL)
        hFuncExtToggleWnd = theAPI.zeofunc_GetFunc("CopyPaste.ExtToggleWnd");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtToggleWnd, NULL, &hRetVar);
    return;
}
bool edit_copy ()
{
    static ZFUNC hFunccopy = NULL;
    
    if (hFunccopy == NULL)
        hFunccopy = theAPI.zeofunc_GetFunc("edit.copy");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFunccopy, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool edit_paste ()
{
    static ZFUNC hFuncpaste = NULL;
    
    if (hFuncpaste == NULL)
        hFuncpaste = theAPI.zeofunc_GetFunc("edit.paste");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncpaste, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
void atExportArea_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atExportArea.ExtAbout");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAbout, NULL, &hRetVar);
    return;
}
bool atExportArea_ExtExportAreaUI ()
{
    static ZFUNC hFuncExtExportAreaUI = NULL;
    
    if (hFuncExtExportAreaUI == NULL)
        hFuncExtExportAreaUI = theAPI.zeofunc_GetFunc("atExportArea.ExtExportAreaUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtExportAreaUI, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool atExportArea_ExtExportAreaUIEx ()
{
    static ZFUNC hFuncExtExportAreaUIEx = NULL;
    
    if (hFuncExtExportAreaUIEx == NULL)
        hFuncExtExportAreaUIEx = theAPI.zeofunc_GetFunc("atExportArea.ExtExportAreaUIEx");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtExportAreaUIEx, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
void atFilterAM_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atFilterAM.ExtAbout");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAbout, NULL, &hRetVar);
    return;
}
void atFilterAM_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atFilterAM.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void atFilterAM_ExtFilterAM ()
{
    static ZFUNC hFuncExtFilterAM = NULL;
    
    if (hFuncExtFilterAM == NULL)
        hFuncExtFilterAM = theAPI.zeofunc_GetFunc("atFilterAM.ExtFilterAM");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtFilterAM, NULL, &hRetVar);
    return;
}
void atFilterAM_ExtAlphaExpress_UI ()
{
    static ZFUNC hFuncExtAlphaExpress_UI = NULL;
    
    if (hFuncExtAlphaExpress_UI == NULL)
        hFuncExtAlphaExpress_UI = theAPI.zeofunc_GetFunc("atFilterAM.ExtAlphaExpress.UI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAlphaExpress_UI, NULL, &hRetVar);
    return;
}
bool atFilterAM_ExtEditFilterList ()
{
    static ZFUNC hFuncExtEditFilterList = NULL;
    
    if (hFuncExtEditFilterList == NULL)
        hFuncExtEditFilterList = theAPI.zeofunc_GetFunc("atFilterAM.ExtEditFilterList");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtEditFilterList, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
void atGrowTilesByOne_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtAbout");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAbout, NULL, &hRetVar);
    return;
}
void atGrowTilesByOne_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
bool atGrowTilesByOne_ExtGrowTilesByOne (ZMAP hMap, const char * FileNameStr, ZFORMAT hFormat)
{
    static ZFUNC hFuncExtGrowTilesByOne = NULL;
    
    if (hFuncExtGrowTilesByOne == NULL)
        hFuncExtGrowTilesByOne = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowTilesByOne");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarFileNameStr = theAPI.list_CreateItem(hArgs, VarID_string, "FileNameStr");
    theAPI.str_SetText(hVarFileNameStr, FileNameStr);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtGrowTilesByOne, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool atGrowTilesByOne_ExtGrowMapByOne (ZMAP hMap, const char * FileNameStr, ZFORMAT hFormat)
{
    static ZFUNC hFuncExtGrowMapByOne = NULL;
    
    if (hFuncExtGrowMapByOne == NULL)
        hFuncExtGrowMapByOne = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowMapByOne");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarhMap = theAPI.list_CreateItem(hArgs, VarID_map, "hMap");
    theAPI.var_SetVarRef(hVarhMap, hMap);

    ZVAR hVarFileNameStr = theAPI.list_CreateItem(hArgs, VarID_string, "FileNameStr");
    theAPI.str_SetText(hVarFileNameStr, FileNameStr);

    ZVAR hVarhFormat = theAPI.list_CreateItem(hArgs, VarID_format, "hFormat");
    theAPI.var_SetVarRef(hVarhFormat, hFormat);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtGrowMapByOne, hArgs, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}

bool atGrowTilesByOne_ExtGrowMapByOneUI ()
{
    static ZFUNC hFuncExtGrowMapByOneUI = NULL;
    
    if (hFuncExtGrowMapByOneUI == NULL)
        hFuncExtGrowMapByOneUI = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowMapByOneUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtGrowMapByOneUI, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
bool atGrowTilesByOne_ExtGrowTilesByOneUI ()
{
    static ZFUNC hFuncExtGrowTilesByOneUI = NULL;
    
    if (hFuncExtGrowTilesByOneUI == NULL)
        hFuncExtGrowTilesByOneUI = theAPI.zeofunc_GetFunc("atGrowTilesByOne.ExtGrowTilesByOneUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtGrowTilesByOneUI, NULL, &hRetVar);
    
    if (bExecResult)
    {
        bool retValue;
        theAPI.var_GetValue(hRetVar, &retValue);
        return retValue;
    }
    return 0;

}
void atFuncBrowser_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void atFuncBrowser_ExtShowFuncBrowser ()
{
    static ZFUNC hFuncExtShowFuncBrowser = NULL;
    
    if (hFuncExtShowFuncBrowser == NULL)
        hFuncExtShowFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtShowFuncBrowser");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtShowFuncBrowser, NULL, &hRetVar);
    return;
}
void atFuncBrowser_ExtHideFuncBrowser ()
{
    static ZFUNC hFuncExtHideFuncBrowser = NULL;
    
    if (hFuncExtHideFuncBrowser == NULL)
        hFuncExtHideFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtHideFuncBrowser");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtHideFuncBrowser, NULL, &hRetVar);
    return;
}
void atFuncBrowser_ExtToggleFuncBrowser ()
{
    static ZFUNC hFuncExtToggleFuncBrowser = NULL;
    
    if (hFuncExtToggleFuncBrowser == NULL)
        hFuncExtToggleFuncBrowser = theAPI.zeofunc_GetFunc("atFuncBrowser.ExtToggleFuncBrowser");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtToggleFuncBrowser, NULL, &hRetVar);
    return;
}
void ZeoScript_RunScript (const char * ScriptStr)
{
    static ZFUNC hFuncRunScript = NULL;
    
    if (hFuncRunScript == NULL)
        hFuncRunScript = theAPI.zeofunc_GetFunc("ZeoScript.RunScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarScriptStr = theAPI.list_CreateItem(hArgs, VarID_string, "ScriptStr");
    theAPI.str_SetText(hVarScriptStr, ScriptStr);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncRunScript, hArgs, &hRetVar);
    return;
}

void ZeoScript_RunScriptUI ()
{
    static ZFUNC hFuncRunScriptUI = NULL;
    
    if (hFuncRunScriptUI == NULL)
        hFuncRunScriptUI = theAPI.zeofunc_GetFunc("ZeoScript.RunScriptUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncRunScriptUI, NULL, &hRetVar);
    return;
}
void ZeoScript_LoadScript (const char * FileName)
{
    static ZFUNC hFuncLoadScript = NULL;
    
    if (hFuncLoadScript == NULL)
        hFuncLoadScript = theAPI.zeofunc_GetFunc("ZeoScript.LoadScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadScript, hArgs, &hRetVar);
    return;
}

void ZeoScript_LoadScriptUI ()
{
    static ZFUNC hFuncLoadScriptUI = NULL;
    
    if (hFuncLoadScriptUI == NULL)
        hFuncLoadScriptUI = theAPI.zeofunc_GetFunc("ZeoScript.LoadScriptUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadScriptUI, NULL, &hRetVar);
    return;
}
void ZeoScript_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("ZeoScript.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void cdPython_ExtAbout ()
{
    static ZFUNC hFuncExtAbout = NULL;
    
    if (hFuncExtAbout == NULL)
        hFuncExtAbout = theAPI.zeofunc_GetFunc("cdPython.ExtAbout");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtAbout, NULL, &hRetVar);
    return;
}
void cdPython_LoadScriptUI ()
{
    static ZFUNC hFuncLoadScriptUI = NULL;
    
    if (hFuncLoadScriptUI == NULL)
        hFuncLoadScriptUI = theAPI.zeofunc_GetFunc("cdPython.LoadScriptUI");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadScriptUI, NULL, &hRetVar);
    return;
}
void cdPython_ExtWikiPage ()
{
    static ZFUNC hFuncExtWikiPage = NULL;
    
    if (hFuncExtWikiPage == NULL)
        hFuncExtWikiPage = theAPI.zeofunc_GetFunc("cdPython.ExtWikiPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtWikiPage, NULL, &hRetVar);
    return;
}
void cdPython_ExtZeoPage ()
{
    static ZFUNC hFuncExtZeoPage = NULL;
    
    if (hFuncExtZeoPage == NULL)
        hFuncExtZeoPage = theAPI.zeofunc_GetFunc("cdPython.ExtZeoPage");

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncExtZeoPage, NULL, &hRetVar);
    return;
}
void cdPython_LoadScript (const char * FileName)
{
    static ZFUNC hFuncLoadScript = NULL;
    
    if (hFuncLoadScript == NULL)
        hFuncLoadScript = theAPI.zeofunc_GetFunc("cdPython.LoadScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarFileName = theAPI.list_CreateItem(hArgs, VarID_string, "FileName");
    theAPI.str_SetText(hVarFileName, FileName);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncLoadScript, hArgs, &hRetVar);
    return;
}

void cdPython_RunScript (const char * ScriptStr)
{
    static ZFUNC hFuncRunScript = NULL;
    
    if (hFuncRunScript == NULL)
        hFuncRunScript = theAPI.zeofunc_GetFunc("cdPython.RunScript");

    ZLIST hArgs = theAPI.var_CreateTemp(VarID_varlist);
    

    ZVAR hVarScriptStr = theAPI.list_CreateItem(hArgs, VarID_string, "ScriptStr");
    theAPI.str_SetText(hVarScriptStr, ScriptStr);

    ZVAR hRetVar = 0;
    bool bExecResult = theAPI.zeofunc_Execute2(hFuncRunScript, hArgs, &hRetVar);
    return;
}

/* EOF */

